package admin

import (
	"fmt"
	"geekai/api/dto/request"
	"geekai/api/dto/response"
	"geekai/api/handler"
	"geekai/core"
	"geekai/core/types"
	"geekai/model"
	"geekai/utils"
	"github.com/gin-gonic/gin"
	"gorm.io/gorm"
	"time"
)

type ChatAppHandler struct {
	handler.BaseHandler
}

func NewChatAppHandler(app *core.AppServer, db *gorm.DB) *ChatAppHandler {
	return &ChatAppHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}}
}

// SaveOrUpdate godoc
// @Summary      创建或者更新应用角色
// @Description  创建或者更新应用角色
// @Tags         后台管理-应用管理
// @Accept       json
// @Produce      json
// @Param        req   body     request.ChatRole  true  "应用信息"
// @Success      200  {object}  types.BizVo{data=response.ChatRole}
// @Router       /api/admin/role/saveOrUpdate [post]
// @Security AdminApiKeyAuth
func (h *ChatAppHandler) SaveOrUpdate(c *gin.Context) {
	var data request.ChatRole
	if err := c.ShouldBindJSON(&data); err != nil {
		utils.ERROR(c, types.InvalidArgs)
		return
	}

	var role model.ChatRole
	err := utils.CopyObject(data, &role)
	if err != nil {
		utils.ERROR(c, types.InvalidArgs)
		return
	}

	role.Id = data.Id
	// 如果 CreatedAt 大于 0 就表示这条数据已经存在
	if data.CreatedAt > 0 {
		role.CreatedAt = time.Unix(data.CreatedAt, 0)
	} else {
		err = h.DB.Where("marker", data.Key).First(&role).Error
		if err == nil {
			utils.ERROR(c, fmt.Sprintf("角色 %s 已经存在", data.Key))
			return
		}
	}

	err = h.DB.Save(&role).Error
	if err != nil {
		utils.ERROR(c, "应用角色数据操作失败："+err.Error())
		return
	}
	var roleResp response.ChatRole
	err = utils.CopyObject(data, &roleResp)
	if err == nil {
		roleResp.Id = role.Id
		roleResp.CreatedAt = role.CreatedAt.Unix()
		roleResp.UpdatedAt = role.CreatedAt.Unix()
	} else {
		utils.ERROR(c, "拷贝应用角色数据失败："+err.Error())
		return
	}
	utils.SUCCESS(c, roleResp)
}

// List godoc
// @Summary      查询应用列表
// @Description  查询应用列表
// @Tags         后台管理-应用管理
// @Accept       json
// @Produce      json
// @Success      200  {object}  types.BizVo{data=[]response.ChatRole}
// @Router       /api/admin/role/list [get]
// @Security AdminApiKeyAuth
func (h *ChatAppHandler) List(c *gin.Context) {
	var items []model.ChatRole
	var roles = make([]response.ChatRole, 0)
	res := h.DB.Order("sort_num ASC").Find(&items)
	if res.Error != nil {
		utils.ERROR(c, "没有查询到数据")
		return
	}

	// 模型Id集合
	modelIds := make([]int, 0)
	// 分类Id集合
	typeIds := make([]int, 0)
	for _, v := range items {
		if v.ModelId > 0 {
			modelIds = append(modelIds, v.ModelId)
		}
		if v.Tid > 0 {
			typeIds = append(typeIds, v.Tid)
		}
	}

	// 模型名称
	modelNameMap := make(map[int]string)
	// 类型名称
	typeNameMap := make(map[int]string)

	if len(modelIds) > 0 {
		var models []model.ChatModel
		// 查询模型
		tx := h.DB.Where("id IN ?", modelIds).Find(&models)
		if tx.Error == nil {
			// 遍历模型
			for _, m := range models {
				modelNameMap[int(m.Id)] = m.Name
			}
		}
	}

	if len(typeIds) > 0 {
		var appTypes []model.AppType
		// 查询应用分类
		tx := h.DB.Where("id IN ?", typeIds).Find(&appTypes)
		if tx.Error == nil {
			// 遍历应用分类
			for _, a := range appTypes {
				typeNameMap[int(a.Id)] = a.Name
			}
		}
	}

	for _, v := range items {
		var role response.ChatRole
		err := utils.CopyObject(v, &role)
		if err == nil {
			role.Id = v.Id
			role.CreatedAt = v.CreatedAt.Unix()
			role.UpdatedAt = v.UpdatedAt.Unix()
			role.ModelName = modelNameMap[role.ModelId]
			role.TypeName = typeNameMap[role.Tid]
			roles = append(roles, role)
		}
	}
	utils.SUCCESS(c, roles)
}

// Sort godoc
// @Summary      更新应用角色排序
// @Description  更新应用角色排序
// @Tags         后台管理-应用管理
// @Accept       json
// @Produce      json
// @Param        req   body     request.ChatAppUpdateSortReq  true  "应用角色排序"
// @Success      200  {object}  types.BizVo{}
// @Router       /api/admin/role/sort [post]
// @Security AdminApiKeyAuth
func (h *ChatAppHandler) Sort(c *gin.Context) {
	var data request.ChatAppUpdateSortReq
	if err := c.ShouldBindJSON(&data); err != nil {
		utils.ERROR(c, types.InvalidArgs)
		return
	}
	for index, id := range data.Ids {
		err := h.DB.Model(&model.ChatRole{}).Where("id = ?", id).Update("sort_num", data.Sorts[index]).Error
		if err != nil {
			utils.ERROR(c, "更新应用排序出错："+err.Error())
			return
		}
	}
	utils.SUCCESS(c)
}

// Set godoc
// @Summary      修改指定字段的值
// @Description  修改指定字段的值
// @Tags         后台管理-应用管理
// @Accept       json
// @Produce      json
// @Param        req   body     request.ChatAppUpdateFiledReq  true  "字段信息"
// @Success      200  {object}  types.BizVo{}
// @Router       /api/admin/role/set [post]
// @Security AdminApiKeyAuth
func (h *ChatAppHandler) Set(c *gin.Context) {
	var data request.ChatAppUpdateFiledReq
	if err := c.ShouldBindJSON(&data); err != nil {
		utils.ERROR(c, types.InvalidArgs)
		return
	}
	err := h.DB.Model(&model.ChatRole{}).Where("id = ?", data.Id).Update(data.Filed, data.Value).Error
	if err != nil {
		utils.ERROR(c, "修改数据出现错误："+err.Error())
		return
	}
	utils.SUCCESS(c)
}

// Remove godoc
// @Summary      删除应用数据
// @Description  删除应用数据
// @Tags         后台管理-应用管理
// @Accept       json
// @Produce      json
// @Param        id   query     int  true  "删除数据的Id"
// @Success      200  {object}  types.BizVo{}
// @Router       /api/admin/role/remove [get]
// @Security AdminApiKeyAuth
func (h *ChatAppHandler) Remove(c *gin.Context) {
	id := h.GetInt(c, "id", 0)
	if id <= 0 {
		utils.ERROR(c, types.InvalidArgs)
		return
	}
	res := h.DB.Where("id", id).Delete(&model.ChatRole{})
	if res.Error != nil {
		log.Errorf("删除数据出现错误：%v", res.Error.Error())
		utils.ERROR(c, "删除数据出现错误："+res.Error.Error())
		return
	}
	utils.SUCCESS(c)
}
